home *** CD-ROM | disk | FTP | other *** search
/ Programming Windows 95 / Programming Windows 95.iso / code / CHAP12 / GADGETS.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-01-01  |  17.2 KB  |  481 lines
  1. /*-----------------------------------------
  2.    GADGETS.C -- Gadgets for a frame window.
  3.                  (c) Paul Yao, 1996
  4.   -----------------------------------------*/
  5. #include <windows.h>
  6. #include <windowsx.h>
  7. #include <commctrl.h>
  8. #include "comcthlp.h"
  9. #include "gadgets.h"
  10.  
  11. LRESULT CALLBACK WndProc (HWND, UINT, WPARAM, LPARAM) ;
  12. LRESULT CALLBACK ClientWndProc (HWND, UINT, WPARAM, LPARAM) ;
  13.  
  14. char szAppName[]  = "Gadgets" ;
  15. BOOL bIgnoreSize = FALSE ;
  16. HINSTANCE hInst ;
  17. HWND hwndClient = NULL ;
  18. HWND hwndToolBar = NULL ;
  19. HWND hwndStatusBar = NULL ;
  20. HWND hwndNotify = NULL ;
  21.  
  22. extern DWORD dwToolBarStyles ;
  23. extern BOOL bStrings ;
  24. extern BOOL bLargeIcons ;
  25. extern BOOL bComboBox ;
  26. extern DWORD dwStatusBarStyles ;
  27. extern int cyToolBar ;
  28.  
  29. //-------------------------------------------------------------------
  30. int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, 
  31.                     PSTR lpszCmdLine, int cmdShow)       
  32.      {
  33.      HWND        hwnd ;
  34.      MSG         msg ;
  35.      WNDCLASSEX  wc ;
  36.  
  37.      hInst = hInstance ;
  38.  
  39.      wc.cbSize        = sizeof (wc) ;
  40.      wc.lpszClassName = szAppName ;
  41.      wc.hInstance     = hInstance ;
  42.      wc.lpfnWndProc   = WndProc ;
  43.      wc.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
  44.      wc.hIcon         = LoadIcon (hInst, MAKEINTRESOURCE (IDI_APP)) ;
  45.      wc.lpszMenuName  = "MAIN" ;
  46.      wc.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1);
  47.      wc.style         = 0 ;
  48.      wc.cbClsExtra    = 0 ;
  49.      wc.cbWndExtra    = 0 ;
  50.      wc.hIconSm       = LoadIcon (hInst, MAKEINTRESOURCE (IDI_APP)) ;
  51.  
  52.      RegisterClassEx (&wc) ;
  53.  
  54.      wc.lpszClassName = "ClientWndProc" ;
  55.      wc.hInstance     = hInstance ;
  56.      wc.lpfnWndProc   = ClientWndProc ;
  57.      wc.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
  58.      wc.hIcon         = LoadIcon (NULL, IDI_APPLICATION) ;
  59.      wc.lpszMenuName  = NULL ;
  60.      wc.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1) ;
  61.      wc.style         = 0 ;
  62.      wc.cbClsExtra    = 0 ;
  63.      wc.cbWndExtra    = 0 ;
  64.      wc.hIconSm       = LoadIcon (NULL, IDI_APPLICATION) ;
  65.  
  66.      RegisterClassEx (&wc) ;
  67.  
  68.      hwnd = CreateWindowEx(0L,
  69.                            szAppName, szAppName,
  70.                            WS_OVERLAPPEDWINDOW,  
  71.                            CW_USEDEFAULT, CW_USEDEFAULT,
  72.                            CW_USEDEFAULT, CW_USEDEFAULT,
  73.                            NULL, NULL, hInstance, NULL) ;
  74.      ShowWindow (hwnd, cmdShow) ;
  75.      UpdateWindow (hwnd) ;
  76.  
  77.      InitCommonControls () ;
  78.  
  79.      while (GetMessage (&msg, NULL, 0, 0))
  80.           {
  81.           TranslateMessage (&msg) ; 
  82.           DispatchMessage (&msg) ;  
  83.           }
  84.      return msg.wParam ;
  85.      }
  86.  
  87. //-------------------------------------------------------------------
  88. void MenuCheckMark (HMENU hmenu, int id, BOOL bCheck)
  89.      {
  90.      int iState ;
  91.      iState = (bCheck) ? MF_CHECKED : MF_UNCHECKED ;
  92.      CheckMenuItem (hmenu, id, iState) ;
  93.      }
  94.  
  95. //-------------------------------------------------------------------
  96. LRESULT CALLBACK
  97. WndProc (HWND hwnd, UINT mMsg, WPARAM wParam, LPARAM lParam) 
  98.      {
  99.      switch (mMsg)
  100.           {
  101.           case WM_CREATE :
  102.                {
  103.                // Create toolbar (source resides in toolbar.c).
  104.                hwndToolBar = InitToolBar (hwnd) ;
  105.  
  106.                // Create status bar (source resides in statbar.c).
  107.                hwndStatusBar = InitStatusBar (hwnd) ;
  108.  
  109.                // Create client window (contains notify list).
  110.                hwndClient = CreateWindowEx (WS_EX_CLIENTEDGE,
  111.                                  "ClientWndProc", NULL,
  112.                                  WS_CHILD | WS_VISIBLE, 0, 0, 0, 0,
  113.                                  hwnd, (HMENU) 4, hInst, NULL) ;
  114.  
  115.                return 0 ;
  116.                }
  117.  
  118.           case WM_COMMAND :
  119.                {
  120.                // Toolbar button commands.
  121.                if (LOWORD (wParam) < 300)
  122.                     {
  123.                     char ach[80] ;
  124.                     wsprintf (ach, "Got Command (%d)", wParam) ;
  125.                     MessageBox (hwnd, ach, szAppName, MB_OK) ;
  126.                     break ;
  127.                     }
  128.  
  129.                // Menu item commands
  130.                switch (LOWORD (wParam))
  131.                     {
  132.                     // Toolbar settings
  133.                     case IDM_STRINGS :
  134.                     case IDM_LARGEICONS :
  135.                     case IDM_SMALLICONS :
  136.                     case IDM_NODIVIDER :
  137.                     case IDM_WRAPABLE :
  138.                     case IDM_TOP :
  139.                     case IDM_BOTTOM :
  140.                     case IDM_NOMOVEY :
  141.                     case IDM_NOPARENTALIGN :
  142.                     case IDM_NORESIZE :
  143.                     case IDM_ADJUSTABLE :
  144.                     case IDM_ALTDRAG :
  145.                     case IDM_TOOLTIPS :
  146.                     case IDM_COMBOBOX :
  147.                          DestroyWindow (hwndToolBar) ;
  148.                          hwndToolBar = RebuildToolBar (hwnd, 
  149.                                                        LOWORD (wParam)) ;
  150.                          break ;
  151.  
  152.                     // Toolbar messages
  153.                     case IDM_TB_CHECK :
  154.                     case IDM_TB_ENABLE :
  155.                     case IDM_TB_HIDE :
  156.                     case IDM_TB_INDETERMINATE :
  157.                     case IDM_TB_PRESS :
  158.                     case IDM_TB_BUTTONCOUNT :
  159.                     case IDM_TB_GETROWS :
  160.                     case IDM_TB_CUSTOMIZE :
  161.                          ToolBarMessage (hwndToolBar, LOWORD (wParam)) ;
  162.                          break ;
  163.  
  164.                     // Status bar settings
  165.                     case IDM_STAT_SIZEGRIP :
  166.                     case IDM_STAT_TOP :
  167.                     case IDM_STAT_BOTTOM :
  168.                     case IDM_STAT_NOMOVEY :
  169.                     case IDM_STAT_NOPARENTALIGN :
  170.                     case IDM_STAT_NORESIZE :
  171.                          DestroyWindow (hwndStatusBar) ;
  172.                          hwndStatusBar = RebuildStatusBar (hwnd,
  173.                                                            LOWORD (wParam)) ;
  174.                          break ;
  175.                       
  176.                     // Status bar messages
  177.                     case IDM_ST_GETBORDERS :
  178.                     case IDM_ST_GETPARTS :
  179.                     case IDM_ST_SETTEXT :
  180.                     case IDM_ST_SIMPLE :
  181.                          StatusBarMessage (hwndStatusBar, LOWORD (wParam)) ;
  182.                          break ;
  183.  
  184.                     // Toggle display of toolbar
  185.                     case IDM_VIEW_TOOLBAR :
  186.                          {
  187.                          RECT r ;
  188.  
  189.                          if (hwndToolBar && IsWindowVisible (hwndToolBar))
  190.                               {
  191.                               ShowWindow (hwndToolBar, SW_HIDE) ;
  192.                               }
  193.                          else
  194.                               {
  195.                               ShowWindow (hwndToolBar, SW_SHOW) ;
  196.                               }
  197.  
  198.                          // Resize other windows.
  199.                          GetClientRect (hwnd, &r) ;
  200.                          PostMessage (hwnd, WM_SIZE, 0, 
  201.                                       MAKELPARAM (r.right, r.bottom)) ;
  202.  
  203.                          break;
  204.                          }
  205.  
  206.                     // Toggle display of status bar
  207.                     case IDM_VIEW_STATUS :
  208.                          {
  209.                          RECT r;
  210.  
  211.                          if (hwndStatusBar && IsWindowVisible (hwndStatusBar))
  212.                               {
  213.                               ShowWindow (hwndStatusBar, SW_HIDE) ;
  214.                               }
  215.                          else
  216.                               {
  217.                               ShowWindow (hwndStatusBar, SW_SHOW) ;
  218.                               }
  219.  
  220.                          // Resize other windows.
  221.                          GetClientRect (hwnd, &r) ;
  222.                          PostMessage (hwnd, WM_SIZE, 0, 
  223.                                       MAKELPARAM (r.right, r.bottom)) ;
  224.  
  225.                          break;
  226.                          }
  227.  
  228.                     // Toggle display of notifications window.
  229.                     case IDM_VIEW_NOTIFICATIONS :
  230.                          hwndNotify = ViewNotificationsToggle (hwndClient) ;
  231.                          break ;
  232.  
  233.                     // Toggle ignore WM_SIZE to show auto-size/auto-move
  234.                     case IDM_IGNORESIZE :
  235.                     case IDM_STAT_IGNORESIZE :
  236.                          {
  237.                          RECT r ;
  238.  
  239.                          bIgnoreSize = !bIgnoreSize ;
  240.                          if (bIgnoreSize)
  241.                               {
  242.                               ShowWindow (hwndClient, SW_HIDE) ;
  243.                               }
  244.                          else
  245.                               {
  246.                               ShowWindow (hwndClient, SW_SHOW) ;
  247.                               GetClientRect (hwnd, &r) ;
  248.                               PostMessage (hwnd, WM_SIZE, 0, 
  249.                                            MAKELPARAM (r.right, r.bottom)) ;
  250.                               }
  251.                          break ;
  252.                          }
  253.  
  254.                     // Clear contents of notification window
  255.                     case IDM_NOTIFICATIONS_CLEAR :
  256.                          ClearNotificationList () ;
  257.                          break;
  258.                     }
  259.  
  260.                return 0;
  261.                }
  262.  
  263.           case WM_INITMENU :
  264.                {
  265.                BOOL bCheck ;
  266.                HMENU hmenu = (HMENU) wParam ;
  267.  
  268.                MenuCheckMark (hmenu, IDM_IGNORESIZE, bIgnoreSize) ;
  269.                MenuCheckMark (hmenu, IDM_STAT_IGNORESIZE, bIgnoreSize) ;
  270.  
  271.                // Toolbar menu items.
  272.                MenuCheckMark (hmenu, IDM_STRINGS, bStrings) ;
  273.                MenuCheckMark (hmenu, IDM_LARGEICONS, bLargeIcons) ;
  274.                MenuCheckMark (hmenu, IDM_SMALLICONS, !bLargeIcons) ;
  275.                MenuCheckMark (hmenu, IDM_COMBOBOX, bComboBox) ;
  276.  
  277.                bCheck = (dwToolBarStyles & CCS_NODIVIDER) ;
  278.                MenuCheckMark (hmenu, IDM_NODIVIDER, bCheck) ;
  279.  
  280.                bCheck = (dwToolBarStyles & TBSTYLE_WRAPABLE) ;
  281.                MenuCheckMark(hmenu, IDM_WRAPABLE, bCheck) ;
  282.  
  283.                bCheck = ((dwToolBarStyles & 3) == CCS_TOP) ;
  284.                MenuCheckMark(hmenu, IDM_TOP, bCheck) ;
  285.  
  286.                bCheck = ((dwToolBarStyles & 3) == CCS_BOTTOM) ;
  287.                MenuCheckMark (hmenu, IDM_BOTTOM, bCheck) ;
  288.  
  289.                bCheck = ((dwToolBarStyles & 3) == CCS_NOMOVEY) ;
  290.                MenuCheckMark (hmenu, IDM_NOMOVEY, bCheck) ;
  291.  
  292.                bCheck = (dwToolBarStyles & CCS_NOPARENTALIGN) ;
  293.                MenuCheckMark (hmenu, IDM_NOPARENTALIGN, bCheck) ;
  294.  
  295.                bCheck = (dwToolBarStyles & CCS_NORESIZE) ;
  296.                MenuCheckMark (hmenu, IDM_NORESIZE, bCheck) ;
  297.  
  298.                bCheck = (dwToolBarStyles & CCS_ADJUSTABLE) ;
  299.                MenuCheckMark (hmenu, IDM_ADJUSTABLE, bCheck) ;
  300.  
  301.                bCheck = (dwToolBarStyles & TBSTYLE_ALTDRAG) ;
  302.                MenuCheckMark (hmenu, IDM_ALTDRAG, bCheck) ;
  303.  
  304.                bCheck = (dwToolBarStyles & TBSTYLE_TOOLTIPS) ;
  305.                MenuCheckMark (hmenu, IDM_TOOLTIPS, bCheck) ;
  306.  
  307.                // Status bar menu items.
  308.                bCheck = (dwStatusBarStyles & SBARS_SIZEGRIP) ;
  309.                MenuCheckMark (hmenu, IDM_STAT_SIZEGRIP, bCheck) ;
  310.  
  311.                bCheck = ((dwStatusBarStyles & 3) == CCS_TOP) ;
  312.                MenuCheckMark (hmenu, IDM_STAT_TOP, bCheck) ;
  313.  
  314.                bCheck = ((dwStatusBarStyles & 3) == CCS_BOTTOM) ;
  315.                MenuCheckMark (hmenu, IDM_STAT_BOTTOM, bCheck) ;
  316.  
  317.                bCheck = ((dwStatusBarStyles & 3) == CCS_NOMOVEY) ;
  318.                MenuCheckMark (hmenu, IDM_STAT_NOMOVEY, bCheck) ;
  319.  
  320.                bCheck = (dwStatusBarStyles & CCS_NOPARENTALIGN) ;
  321.                MenuCheckMark (hmenu, IDM_STAT_NOPARENTALIGN, bCheck) ;
  322.  
  323.                bCheck = (dwStatusBarStyles & CCS_NORESIZE) ;
  324.                MenuCheckMark (hmenu, IDM_STAT_NORESIZE, bCheck) ;
  325.  
  326.                // View menu items.
  327.                bCheck = IsWindowVisible (hwndToolBar) ;
  328.                MenuCheckMark (hmenu, IDM_VIEW_TOOLBAR, bCheck) ;
  329.             
  330.                bCheck = IsWindowVisible (hwndStatusBar) ;
  331.                MenuCheckMark (hmenu, IDM_VIEW_STATUS, bCheck) ;
  332.  
  333.                bCheck = (hwndNotify != NULL) ;
  334.                MenuCheckMark (hmenu, IDM_VIEW_NOTIFICATIONS, bCheck) ;
  335.                return 0 ;
  336.                }
  337.  
  338.           case WM_MENUSELECT :
  339.                return Statusbar_MenuSelect (hwnd, wParam, lParam) ;
  340.  
  341.           case WM_DESTROY :
  342.                PostQuitMessage (0) ;
  343.                return 0 ;
  344.  
  345.           case WM_NOTIFY :
  346.                {
  347.                LPNMHDR pnmh = (LPNMHDR) lParam ;
  348.                int idCtrl = (int) wParam ;
  349.  
  350.                // Display notification details in notify window
  351.                DisplayNotificationDetails (wParam, lParam) ;
  352.  
  353.                // Toolbar notifications
  354.                if ((pnmh->code >= TBN_LAST) &&
  355.                    (pnmh->code <= TBN_FIRST))
  356.                     {
  357.                     return ToolBarNotify (hwnd, wParam, lParam) ;
  358.                     }
  359.             
  360.                // Fetch tooltip text
  361.                if (pnmh->code == TTN_NEEDTEXT)
  362.                     {
  363.                     LPTOOLTIPTEXT lpttt = (LPTOOLTIPTEXT) lParam ;
  364.                     CopyToolTipText (lpttt) ;
  365.                     }
  366.  
  367.                return 0 ;
  368.                }
  369.  
  370.           case WM_SIZE :
  371.                {
  372.                int cx = LOWORD (lParam) ;
  373.                int cy = HIWORD (lParam) ;
  374.                int cyStatus ;
  375.                int cyTB ;
  376.                int x, y ;
  377.                DWORD dwStyle ;
  378.                RECT rWindow ;
  379.  
  380.                // Ignore size message to allow auto-move and auto-size
  381.                // features to be more clearly seen.
  382.                if (bIgnoreSize)
  383.                     return 0 ;
  384.  
  385.                // Adjust toolbar size.
  386.                if (IsWindowVisible (hwndToolBar))
  387.                     {
  388.                     dwStyle = GetWindowLong (hwndToolBar, GWL_STYLE) ;
  389.                     if (dwStyle & CCS_NORESIZE)
  390.                          {
  391.                          MoveWindow (hwndToolBar, 
  392.                                      0, 0, cx, cyToolBar, FALSE) ;
  393.                          }
  394.                     else
  395.                          {
  396.                          ToolBar_AutoSize (hwndToolBar) ;
  397.                          }
  398.                     InvalidateRect (hwndToolBar, NULL, TRUE) ;
  399.                     GetWindowRect (hwndToolBar, &rWindow) ;
  400.                     ScreenToClient (hwnd, (LPPOINT) &rWindow.left) ;
  401.                     ScreenToClient (hwnd, (LPPOINT) &rWindow.right) ;
  402.                     cyTB = rWindow.bottom - rWindow.top ;
  403.                     } 
  404.                else
  405.                     {
  406.                     cyTB = 0 ;
  407.                     }
  408.  
  409.                // Adjust status bar size.
  410.                if (IsWindowVisible (hwndStatusBar))
  411.                     {
  412.                     GetWindowRect (hwndStatusBar, &rWindow) ;
  413.                     cyStatus = rWindow.bottom - rWindow.top ;
  414.                     MoveWindow (hwndStatusBar, 0, cy - cyStatus, 
  415.                                               cx, cyStatus, TRUE) ;
  416.                     }
  417.                else
  418.                     {
  419.                     cyStatus = 0 ;
  420.                     }
  421.  
  422.                // Adjust client window size.
  423.                x = 0 ;
  424.                y = cyTB ;
  425.                cy = cy - (cyStatus + cyTB) ;
  426.                MoveWindow (hwndClient, x, y, cx, cy, TRUE) ;
  427.                return 0;
  428.                }
  429.  
  430.           default:
  431.                return (DefWindowProc (hwnd, mMsg, wParam, lParam)) ;
  432.           }
  433.      }
  434.  
  435. //-------------------------------------------------------------------
  436. LRESULT CALLBACK 
  437. ClientWndProc (HWND hwnd, UINT mMsg, WPARAM wParam, LPARAM lParam)
  438.      {
  439.      static COLORREF crBack ;
  440.      static HBRUSH hbr ;
  441.  
  442.      switch (mMsg)
  443.           {
  444.           case WM_CREATE :
  445.                hwndNotify = ViewNotificationsToggle (hwnd) ;
  446.                crBack = GetSysColor (COLOR_APPWORKSPACE) ;
  447.                hbr = CreateSolidBrush (crBack) ;
  448.                return 0 ;
  449.  
  450.           case WM_DESTROY :
  451.                DeleteObject (hbr) ;
  452.                return 0 ;
  453.  
  454.           case WM_CTLCOLORLISTBOX :
  455.                {
  456.                DefWindowProc (hwnd, mMsg, wParam, lParam) ;
  457.                SetBkColor ((HDC) wParam, crBack) ;
  458.                SetBkMode ((HDC) wParam, TRANSPARENT) ;
  459.                return (LRESULT) (HBRUSH) hbr ;
  460.                }
  461.  
  462.           case WM_SIZE :
  463.                {
  464.                HWND hwndNotify = GetWindow (hwnd, GW_CHILD) ;
  465.                int cx = LOWORD (lParam) ;
  466.                int cy = HIWORD (lParam) ;
  467.  
  468.                // Ignore if notification window is absent.
  469.                if (hwndNotify != NULL)
  470.                     {
  471.                     MoveWindow (hwndNotify, 0, 0, cx, cy, TRUE) ;
  472.                     }
  473.  
  474.                return 0 ;
  475.                }
  476.  
  477.           default :
  478.                return (DefWindowProc (hwnd, mMsg, wParam, lParam)) ;
  479.           }
  480.      }
  481.